/**
 * TrackPlayer 服务
 * 封装 react-native-track-player 的播放功能
 * 支持后台播放和通知栏控制
 */

import TrackPlayer, { Capability } from 'react-native-track-player';

class TrackPlayerService {
  constructor() {
    this.isSetup = false;
    this.currentTrackId = null;
  }

  /**
   * 初始化 TrackPlayer
   */
  async setupPlayer() {
    if (this.isSetup) {
      return;
    }

    try {
      await TrackPlayer.setupPlayer({
        autoHandleInterruptions: true,
      });

      await TrackPlayer.updateOptions({
        // 通知栏能力 - 完整功能
        capabilities: [
          Capability.Play,
          Capability.Pause,
          Capability.Stop,
          Capability.JumpForward,
          Capability.JumpBackward,
          Capability.SeekTo,
        ],
        // 紧凑模式显示的按钮（通知栏折叠时）
        compactCapabilities: [
          Capability.JumpBackward, // 快退15秒
          Capability.Play,
          Capability.Pause,
          Capability.JumpForward, // 快进15秒
        ],
        // 快进/快退步长（15秒）
        forwardJumpInterval: 15,
        backwardJumpInterval: 15,
        // 通知栏图标（展开时显示）
        notificationCapabilities: [
          Capability.Play,
          Capability.Pause,
          Capability.Stop,
          Capability.JumpForward,
          Capability.JumpBackward,
          Capability.SeekTo, // 允许拖动进度条
        ],
        // 进度更新间隔（秒）
        progressUpdateEventInterval: 1,
        // Android 特定配置
        android: {
          appKilledPlaybackBehavior: 'StopPlaybackAndRemoveNotification',
        },
      });

      this.isSetup = true;
    } catch (error) {
      console.error('❌ TrackPlayer 初始化失败:', error);
      throw error;
    }
  }

  /**
   * 重置播放器
   */
  async reset() {
    try {
      await TrackPlayer.reset();
      this.currentTrackId = null;
    } catch (error) {
      console.error('❌ TrackPlayer 重置失败:', error);
    }
  }

  /**
   * 添加或更新 Track
   * @param {Object} track - Track 信息
   * @param {string} track.id - Track ID
   * @param {string} track.url - 音频 URL
   * @param {string} track.title - 标题
   * @param {string} track.artist - 艺术家（景区名称）
   * @param {string} track.artwork - 封面图 URL
   * @param {number} track.duration - 时长（秒）
   */
  async addOrUpdateTrack(track) {
    try {
      if (!this.isSetup) {
        await this.setupPlayer();
      }

      // 构建 track 数据（2.x 版本最小化配置，避免 resolveAssetSource 错误）
      // 注意：只传递最基本的字段，避免 2.1.3 版本的 resolveAssetSource bug
      const trackData = {
        url: String(track.url), // 必须字段
        title: String(track.title || '景区音频'),
        artist: String(track.artist || '山猫导游'),
        // 不传递 id、album、duration、artwork 等任何可能触发 bug 的字段
      };

      // 检查当前队列
      const queue = await TrackPlayer.getQueue();

      if (queue.length > 0) {
        // 如果是同一个 Track（比对URL），不需要重新添加
        const existingTrack = queue[0];
        if (existingTrack && existingTrack.url === trackData.url) {
          return;
        }

        // 不同的 Track，清空队列重新添加
        await TrackPlayer.reset();
      }

      // 添加新 Track（使用最简单的数据结构）
      await TrackPlayer.add([trackData]);
      this.currentTrackId = trackData.url; // 使用URL作为ID

      // 不更新元数据，避免触发错误

    } catch (error) {
      console.error('❌ 添加 Track 失败:', error);
      // 打印详细错误信息以便调试
      console.error('Track 数据:', JSON.stringify(track, null, 2));
      throw error;
    }
  }

  /**
   * 播放
   */
  async play() {
    try {
      await TrackPlayer.play();
    } catch (error) {
      console.error('❌ 播放失败:', error);
      throw error;
    }
  }

  /**
   * 暂停
   */
  async pause() {
    try {
      await TrackPlayer.pause();
    } catch (error) {
      console.error('❌ 暂停失败:', error);
      throw error;
    }
  }

  /**
   * 停止
   */
  async stop() {
    try {
      await TrackPlayer.stop();
      await TrackPlayer.reset();
      this.currentTrackId = null;
    } catch (error) {
      console.error('❌ 停止失败:', error);
      throw error;
    }
  }

  /**
   * 跳转到指定位置
   * @param {number} position - 位置（秒）
   */
  async seekTo(position) {
    try {
      await TrackPlayer.seekTo(position);
    } catch (error) {
      console.error('❌ 跳转失败:', error);
      throw error;
    }
  }

  /**
   * 快进 15 秒
   */
  async jumpForward() {
    try {
      const position = await TrackPlayer.getPosition();
      await TrackPlayer.seekTo(position + 15);
    } catch (error) {
      console.error('❌ 快进失败:', error);
    }
  }

  /**
   * 快退 15 秒
   */
  async jumpBackward() {
    try {
      const position = await TrackPlayer.getPosition();
      await TrackPlayer.seekTo(Math.max(0, position - 15));
    } catch (error) {
      console.error('❌ 快退失败:', error);
    }
  }

  /**
   * 获取当前播放位置
   */
  async getPosition() {
    try {
      return await TrackPlayer.getPosition();
    } catch (error) {
      return 0;
    }
  }

  /**
   * 获取时长
   */
  async getDuration() {
    try {
      return await TrackPlayer.getDuration();
    } catch (error) {
      return 0;
    }
  }

  /**
   * 获取播放状态
   */
  async getState() {
    try {
      return await TrackPlayer.getState();
    } catch (error) {
      return null;
    }
  }

  /**
   * 更新通知栏元数据
   * @param {Object} metadata - 元数据
   */
  async updateMetadata(metadata) {
    try {
      const queue = await TrackPlayer.getQueue();
      if (queue.length > 0) {
        await TrackPlayer.updateMetadataForTrack(0, metadata);
      }
    } catch (error) {
      console.error('❌ 更新元数据失败:', error);
    }
  }
}

// 导出单例
const trackPlayerService = new TrackPlayerService();
export default trackPlayerService;
